package de.hdm.articastle.physics;

import java.util.Random;

import android.graphics.Color;

public class LandscapeGenerator {
	/**
     * Aus balancing Gruenden koennte die Landschaft in der Mitte gespiegelt
     * werden. Der Methode wird die Breite der Landschaft in pixeln uebergeben.
     * Es wird ueberprueft ob die Landschaft mindestens einen Berg mit 70% der
     * Screenhoehe enthaelt.
     * Als Rueckgabewert bekommt man ein array mit allen Punkten der
     * Landschaft.
     * @param width
     * @return landschaft
     */
    public static int[] generateLandscape(int width, int screenHeight, 
                    boolean mirror) {
            boolean balancedMap = false;
            int[] landscape = null;
            while (!balancedMap) {
                    landscape = generateMap(width, screenHeight, mirror);
                    for (int i = width / 4; i < landscape.length * 0.75; i++) {
                            if (landscape[i] >= screenHeight * 0.5)
                                    balancedMap = true;
                    }
            }
            return landscape;
    }
    
    /**
     * Aus balancing Gruenden koennte die Landschaft in der Mitte gespiegelt
     * werden. Der Methode wird die Breite der Landschaft in pixeln uebergeben.
     * Als Rueckgabewert bekommt man ein array mit allen Punkten der
     * Landschaft.
     * @param width
     * @return landschaft
     */
    private static int[] generateMap(int width, int screenHeight, 
                    boolean mirror) {
            Random rnd = new Random();
            int plus = 1;
            int factor = 1;
            int[] landscape = new int[width];
            
            int start = Math.abs(
                            (int) (screenHeight * 0.1) + (rnd.nextInt() % 50));
            landscape[0] = start;
            
            if (mirror) {
                    width = width / 2;
            }
            
            for (int i = 1; i < width; i++) {
                    int last = landscape[i - 1];
                    // Richtung wechseln?
                    boolean change = Math.abs(rnd.nextInt() % 10) > 8;
                    
                    if (change) {
                            factor = -(factor);
                            
                            plus = 1 + Math.abs(rnd.nextInt() % 2);
                    }
                    else if (last > screenHeight * 0.75 || last < screenHeight * 0.2) {
                            factor = -(factor);
                    }
                    
                    landscape[i] = last + factor * plus;
            }
            
            if (mirror) {
                    int j = width - 1;
                    for (int i = width; i < landscape.length; i++) {
                            landscape[i] = landscape[j];
                            j--;
                    }
            }
            
            return landscape;
    }

    public static int[] generateColors(int width) {
            Random rnd = new Random();
            int[] colors = new int[width];
            int plus = 1;
            int factor = 1;
            int greenvalue = 200;
            int redvalue = Math.abs(rnd.nextInt() % 200);
            int bluevalue = Math.abs(rnd.nextInt() % 201);
            
            colors[0] = Color.rgb(redvalue, greenvalue, bluevalue);
            
            for (int i = 1; i < width; i++) {
                    boolean change = Math.abs(rnd.nextInt() % 10) > 8;
                    
                    if (change) {
                            factor = -(factor);
                            
                            plus = 1 + Math.abs(rnd.nextInt() % 2);
                    }
                    
                    if (greenvalue > 240) {
                            greenvalue -= 10;
                    }
                    else if (greenvalue < 100) {
                            greenvalue += 10;
                    }
                    
                    greenvalue = greenvalue + (-factor * plus);
                    colors[i] = Color.rgb(redvalue, greenvalue, bluevalue);
            }
            
            return colors;
    }

}
